#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include<set>
using namespace std;
#define int long long
const int N = 505;
const int M = 300005;
int n, m, r;
int d[N], k[N], p[N];
int dp[M];
int sum;
int t[M], cnt;
int pre[N];


void solve() {
	cin >> n >> m >> r;
	for (int i = 1; i <= n; i++) {
		cin >> d[i] >> k[i] >> p[i];
		pre[i] = 1;
	}
	for (int i = 1,x,y; i <= m; i++) {
		cin >> x >> y;
		sum += y;
		for (int i = 1; i <= y; i++)t[++cnt] = x;
	}
	sort(t + 1, t + 1 + cnt);

	for (int i = 1; i <= sum; i++)dp[i] = 1e18;
	for (int i = 1; i <= sum; i++) {
		dp[i] = min(dp[i - 1] + r, dp[i]);
		for (int j = 1; j <= n; j++) {
			while (pre[j]<i && i - pre[j]+1>k[j] || t[i] - t[pre[j]] >= d[j]) { 
				pre[j]++;
			}
			dp[i] = min(dp[i], dp[pre[j]-1] + p[j]);
		}
	}
	cout << dp[sum] << '\n';
}

signed main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	solve();
	return 0;
}


//constexpr int MAXN = 1e6 + 30;
//int a[MAXN], b[MAXN];
//pair<int, int> p[MAXN];
//signed main() {
//    int n; cin >> n;
//    set<pair<int, int> > s;
//    for (int i = 1; i <= n; ++i) {
//        cin >> a[i];
//        p[i] = { a[i],i };
//    }
//    sort(p + 1, p + n + 1);
//    for (int i = 1; i <= n; ++i) {
//        b[p[i].second] = i;
//    }
//    int cnt = 0;
//    int r = 1;
//    for (int i = 1; i <= n; ++i) {
//        r = max(r, b[i]);
//        if (r == i) ++cnt;
//    }
//    cout << cnt;
//}

//int n;
//
//void solve() {
//	cin >> n;
//
//}
//
//signed main() {
//	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
//	solve();
//	return 0;
//}

//int n, k;
//int a[1005];
//void solve() {
//	cin >> n >> k;
//	for (int i = 1; i <= n; i++) {
//		cin >> a[i];
//	}
//	sort(a + 1, a + 1 + n);
//	int res = 0;
//	for (int i = n; i >= 1 && i > n - k; i--) {
//		res += a[i];
//	}
//	cout << res << '\n';
//}


//int X[N], Y[N], z[N], idz[N], cntz, tot;
//int rt[N], ans[N];
//
//struct node
//{
//	int lc, rc, mx, id;
//}tr[N * 80];
//
//
//int n, m;
//
//void init(int u, int fa) {
//	dp[u] = dp[fa] + 1; st[u][0] = fa;
//	for (int i = 1; i <= lg[dp[u]]; i++) {
//		st[u][i] = st[st[u][i - 1]][i - 1];
//	}
//	for (int v : e[u]) {
//		if (v != fa) {
//			init(v, u);
//		}
//	}
//}
//
//int LCA(int x, int y) {
//	if (dp[x] < dp[y])swap(x, y);
//	while (dp[x] > dp[y]) {
//		x = st[x][lg[dp[x] - dp[y]]];
//	}
//	if (x == y)return x;
//	for (int i = lg[dp[x]]; i >= 0; i--) {
//		if (st[x][i] != st[y][i]) {
//			x = st[x][i]; y = st[y][i];
//		}
//	}
//	return st[x][0];
//}



//void up(int p) {
//	int lc = tr[p].lc, rc = tr[p].rc;
//	if (tr[lc].mx >= tr[rc].mx) {
//		tr[p].mx = tr[lc].mx;
//		tr[p].id = tr[lc].id;
//	}
//	else {
//		tr[p].mx = tr[rc].mx;
//		tr[p].id = tr[rc].id;
//	}
//}
//
//void ins(int& p, int l, int r, int index, int v) {
//	if (!p)p = ++tot;
//	if (l == r) {
//		tr[p].mx += v;
//		tr[p].id = index;
//		return;
//	}
//	int m = (l + r) >> 1;
//	if (index <= m)ins(tr[p].lc, l, m, index, v);
//	else ins(tr[p].rc, m + 1, r, index, v);
//	up(p);
//}
//
//int merge(int p, int q, int l, int r) {
//	if (!p || !q)return p + q;
//	if (l == r) {
//		tr[p].mx += tr[q].mx;
//		return p;
//	}
//	int m = (l + r) >> 1;
//	tr[p].lc = merge(tr[p].lc, tr[q].lc, l, m);
//	tr[p].rc = merge(tr[p].rc, tr[q].rc, m + 1, r);
//	up(p);
//	return p;
//}
//
//void dfs(int u, int fa) {
//	for (int v : e[u]) {
//		if (v != fa) {
//			dfs(v, u);
//			rt[u] = merge(rt[u], rt[v], 1, cntz);
//		}
//	}
//	ans[u] = tr[rt[u]].mx == 0 ? 0 : tr[rt[u]].id;
//}


//vector<int> e[N];
//int X[N], Y[N], z[N], idz[N], cntz, tot;
//int rt[N], ans[N];

//void up(int p) {
//	int lc = tr[p].lc, rc = tr[p].rc;
//	if (tr[lc].mx >= tr[rc].mx) {
//		tr[p].mx = tr[lc].mx;
//		tr[p].id = tr[lc].id;
//	}
//	else {
//		tr[p].mx = tr[rc].mx;
//		tr[p].id = tr[rc].id;
//	}
//}
//
//void ins(int& p, int l, int r, int index, int v) {
//	if (!p)p = ++tot;
//	if (l == r) {
//		tr[p].mx += v;
//		tr[p].id = index;
//		return;
//	}
//	int m = (l + r) >> 1;
//	if (index <= m)ins(tr[p].lc, l, m, index, v);
//	else ins(tr[p].rc, m + 1, r, index, v);
//	up(p);
//}
//
//int merge(int p, int q, int l, int r) {
//	if (!p || !q)return p + q;
//	if (l == r) {
//		tr[p].mx += tr[q].mx;
//		return p;
//	}
//	int m = (l + r) >> 1;
//	tr[p].lc = merge(tr[p].lc, tr[q].lc, l, m);
//	tr[p].rc = merge(tr[p].rc, tr[q].rc, m + 1, r);
//	up(p);
//	return p;
//}


//void dfs(int u, int fa) {
//	for (int v : e[u]) {
//		if (v != fa) {
//			dfs(v, u);
//			rt[u] = merge(rt[u], rt[v], 1, cntz);
//		}
//	}
//	ans[u] = tr[rt[u]].mx == 0 ? 0 : tr[rt[u]].id;
//}
//
//

//void solve() {
//	cin >> n >> m;
//	for (int i = 2; i <= n; i++)lg[i] = lg[i >> 1] + 1;
//	for (int i = 1, u, v; i < n; i++) {
//		cin >> u >> v;
//		e[u].push_back(v);
//		e[v].push_back(u);
//	}
//	for (int i = 1; i <= m; i++) {
//		cin >> X[i] >> Y[i] >> z[i];
//		idz[i] = z[i];
//	}
//	init(1, 0);
//	sort(idz + 1, idz + 1 + m);
//	cntz = unique(idz + 1, idz + 1 + m) - idz - 1;
//	for (int i = 1; i <= m; i++) {
//		int p = LCA(X[i], Y[i]);
//		int index = lower_bound(idz + 1, idz + 1 + cntz, z[i]) - idz;
//		ins(rt[X[i]], 1, cntz, index, 1);
//		ins(rt[Y[i]], 1, cntz, index, 1);
//		ins(rt[p], 1, cntz, index, -1);
//		ins(rt[st[p][0]], 1, cntz, index, -1);
//	}
//	dfs(1, 0);
//	for (int i = 1; i <= n; i++)cout << idz[ans[i]] << '\n';
//}